<div class="selenium-notes">
<h1>Waits with Python in Selenium</h1>
<p>Waits are one of the most important concepts in Selenium automation because modern web applications frequently load elements dynamically. An element may exist in the DOM but may not yet be visible, enabled, clickable, or ready for interaction when Selenium attempts to use it.</p>
<p>Selenium waits allow a Python automation script to synchronize browser actions with the actual state of the web application. Instead of assuming that an element will be immediately available, the script can wait until a required condition is satisfied.</p>
<p>In professional Selenium automation, waits help reduce timing-related failures, improve test stability, and make scripts more reliable when working with dynamic pages, AJAX requests, animations, delayed elements, frames, alerts, windows, and asynchronous application behavior.</p>
<p><strong>Course Resource:</strong> <a href="https://www.justacademy.co/course-detail/selenium-training" target="_blank" rel="noopener noreferrer">Selenium Training</a> | <a href="https://www.justacademy.co/register-for-course-demo" target="_blank" rel="noopener noreferrer">Register for Course Demo</a></p>
<hr>
<h2>1. What are Waits in Selenium?</h2>
<p>A Selenium wait is a synchronization mechanism that instructs WebDriver to pause execution until a specified condition is satisfied or a timeout is reached.</p>
<p>Without proper synchronization, Selenium may attempt to interact with an element before the browser has finished rendering or updating the page.</p>
<h3>Basic Example</h3>
<pre><code>from selenium.webdriver.support.ui import WebDriverWait
wait = WebDriverWait(driver, 10)</code></pre>
<p>The above statement creates a wait that can wait for a condition for up to 10 seconds.</p>
<h2>2. Why are Waits Important?</h2>
<p>Web applications are rarely completely static. Pages can contain JavaScript, AJAX requests, animations, lazy-loaded components, asynchronous API calls, dynamic tables, popups, and elements that appear after user interaction.</p>
<ul>
<li>Synchronize automation with the application.</li>
<li>Reduce timing-related failures.</li>
<li>Handle dynamically loaded elements.</li>
<li>Improve test stability.</li>
<li>Reduce unnecessary fixed delays.</li>
<li>Handle asynchronous browser operations.</li>
<li>Wait for elements to become interactable.</li>
<li>Improve reliability of regression tests.</li>
<li>Make automation more maintainable.</li>
</ul>
<h2>3. Selenium Script Without Proper Wait</h2>
<p>Consider a page where a login button appears two seconds after the page loads.</p>
<pre><code>driver.get("https://example.com/login")
driver.find_element(
By.ID,
"login"
).click()</code></pre>
<p>If the button is not ready when Selenium searches for it, the script can fail with an exception such as <code>NoSuchElementException</code> or another interaction-related exception.</p>
<h2>4. Selenium Script with a Wait</h2>
<pre><code>from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
login_button = WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "login")
)
)
login_button.click()</code></pre>
<p>This approach waits for the required condition instead of assuming that the button is immediately ready.</p>
<h2>5. Types of Waits in Selenium</h2>
<p>Selenium automation commonly uses three synchronization approaches:</p>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>Wait Type</th><th>Description</th><th>Typical Usage</th></tr>
<tr><td>Implicit Wait</td><td>Sets a default timeout for element location operations.</td><td>Simple global synchronization.</td></tr>
<tr><td>Explicit Wait</td><td>Waits for a specific condition.</td><td>Dynamic elements and application states.</td></tr>
<tr><td>Fluent Wait</td><td>Provides configurable timeout, polling, and ignored exceptions.</td><td>Advanced synchronization requirements.</td></tr>
</table>
<h2>6. Implicit Wait</h2>
<p>An implicit wait tells WebDriver to wait for a specified amount of time when attempting to locate an element before returning an error.</p>
<pre><code>driver.implicitly_wait(10)</code></pre>
<p>After this configuration, Selenium uses the specified timeout for element-location operations.</p>
<h3>Example</h3>
<pre><code>from selenium import webdriver
from selenium.webdriver.common.by import By
driver = webdriver.Chrome()
driver.implicitly_wait(10)
driver.get("https://example.com")
username = driver.find_element(
By.ID,
"username"
)
username.send_keys("admin")</code></pre>
<h2>7. How Implicit Wait Works</h2>
<pre><code>Find Element
|
v
Element Available?
/ \
Yes No
| |
v v
Return Wait
Element |
v
Search Again
|
v
Timeout Reached?
/ \
No Yes
| |
v v
Retry Exception</code></pre>
<h2>8. Setting an Implicit Wait</h2>
<pre><code>driver.implicitly_wait(10)</code></pre>
<p>The value is specified in seconds.</p>
<pre><code>driver.implicitly_wait(5)</code></pre>
<p>This configures a five-second implicit wait.</p>
<h2>9. Advantages of Implicit Wait</h2>
<ul>
<li>Simple to configure.</li>
<li>Applies globally to element location.</li>
<li>Reduces immediate failures when elements take time to appear.</li>
<li>Requires less repeated code.</li>
</ul>
<h2>10. Limitations of Implicit Wait</h2>
<ul>
<li>It does not express a specific application condition.</li>
<li>It is less precise than explicit waits.</li>
<li>It is not intended for conditions such as waiting for a particular text value.</li>
<li>Mixing implicit and explicit waits can make timing behavior harder to reason about.</li>
<li>It may hide synchronization problems when used as the only waiting strategy.</li>
</ul>
<h2>11. Explicit Wait</h2>
<p>An explicit wait waits for a specific condition before allowing the script to continue.</p>
<p>Python Selenium provides <code>WebDriverWait</code> for explicit waits, and Selenium's expected conditions module provides commonly used conditions.</p>
<h3>Basic Syntax</h3>
<pre><code>WebDriverWait(
driver,
timeout
).until(
condition
)</code></pre>
<h2>12. Basic Explicit Wait Example</h2>
<pre><code>from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
element = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "username")
)
)</code></pre>
<p>The script waits up to 10 seconds for the username element to become visible.</p>
<h2>13. Explicit Wait Flow</h2>
<pre><code>Start Wait
|
v
Check Condition
|
v
Condition Satisfied?
/ \
Yes No
| |
v v
Continue Poll Again
|
v
Timeout Reached?
/ \
No Yes
| |
v v
Retry TimeoutException</code></pre>
<h2>14. WebDriverWait</h2>
<p><code>WebDriverWait</code> is used to wait for a condition until the timeout is reached.</p>
<pre><code>wait = WebDriverWait(driver, 10)
element = wait.until(
EC.visibility_of_element_located(
(By.ID, "username")
)
)</code></pre>
<h2>15. Reusing WebDriverWait</h2>
<p>Instead of creating a new wait object repeatedly, a reusable wait object can be created.</p>
<pre><code>wait = WebDriverWait(driver, 10)
username = wait.until(
EC.visibility_of_element_located(
(By.ID, "username")
)
)
password = wait.until(
EC.visibility_of_element_located(
(By.ID, "password")
)
login_button = wait.until(
EC.element_to_be_clickable(
(By.ID, "login")
)
)</code></pre>
<h2>16. Expected Conditions</h2>
<p>Expected Conditions provide predefined conditions that can be used with explicit waits.</p>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>Condition</th><th>Purpose</th></tr>
<tr><td><code>presence_of_element_located()</code></td><td>Waits until an element is present in the DOM.</td></tr>
<tr><td><code>visibility_of_element_located()</code></td><td>Waits until an element is present and visible.</td></tr>
<tr><td><code>element_to_be_clickable()</code></td><td>Waits until an element is visible and enabled for clicking.</td></tr>
<tr><td><code>presence_of_all_elements_located()</code></td><td>Waits until matching elements are present.</td></tr>
<tr><td><code>visibility_of_all_elements_located()</code></td><td>Waits until matching elements are visible.</td></tr>
<tr><td><code>invisibility_of_element_located()</code></td><td>Waits until an element becomes invisible or is no longer present.</td></tr>
<tr><td><code>text_to_be_present_in_element()</code></td><td>Waits for specific text in an element.</td></tr>
<tr><td><code>title_contains()</code></td><td>Waits until the page title contains specified text.</td></tr>
<tr><td><code>title_is()</code></td><td>Waits until the page title matches expected text.</td></tr>
<tr><td><code>url_contains()</code></td><td>Waits until the URL contains specified text.</td></tr>
<tr><td><code>alert_is_present()</code></td><td>Waits for an alert to appear.</td></tr>
<tr><td><code>frame_to_be_available_and_switch_to_it()</code></td><td>Waits for a frame and switches into it.</td></tr>
<tr><td><code>number_of_windows_to_be()</code></td><td>Waits until the required number of windows exists.</td></tr>
</table>
<h2>17. Presence of Element</h2>
<p><code>presence_of_element_located()</code> waits until an element exists in the DOM. Presence does not necessarily mean that the element is visible or ready for user interaction.</p>
<pre><code>element = WebDriverWait(
driver,
10
).until(
EC.presence_of_element_located(
(By.ID, "username")
)
)</code></pre>
<h2>18. Visibility of Element</h2>
<p><code>visibility_of_element_located()</code> waits until the element is present and visible.</p>
<pre><code>username = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "username")
)
)
username.send_keys("admin")</code></pre>
<h2>19. Presence vs Visibility</h2>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>Presence</th><th>Visibility</th></tr>
<tr><td>Element exists in DOM.</td><td>Element exists and is visible.</td></tr>
<tr><td>Element may not be displayed.</td><td>Element can be displayed.</td></tr>
<tr><td>Useful for DOM-level presence.</td><td>Useful before visual interaction.</td></tr>
</table>
<h2>20. Element to be Clickable</h2>
<p><code>element_to_be_clickable()</code> is useful when the script needs to click an element after it becomes visible and enabled.</p>
<pre><code>button = WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "submit")
)
)
button.click()</code></pre>
<h2>21. Waiting for Multiple Elements</h2>
<p>When a page contains a collection of elements, use <code>presence_of_all_elements_located()</code>.</p>
<pre><code>products = WebDriverWait(
driver,
10
).until(
EC.presence_of_all_elements_located(
(By.CSS_SELECTOR, ".product")
)
)
print("Products:", len(products))</code></pre>
<h2>22. Waiting for All Elements to be Visible</h2>
<pre><code>products = WebDriverWait(
driver,
10
).until(
EC.visibility_of_all_elements_located(
(By.CSS_SELECTOR, ".product")
)
)</code></pre>
<h2>23. Waiting for Invisibility</h2>
<p>Sometimes the script must wait for a loading spinner, popup, overlay, or progress indicator to disappear.</p>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.invisibility_of_element_located(
(By.ID, "loading")
)
)</code></pre>
<h2>24. Waiting for Text</h2>
<p>Dynamic applications may initially display one message and later update it. Explicit waits can be used to wait for specific text.</p>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.text_to_be_present_in_element(
(By.ID, "status"),
"Completed"
)
)</code></pre>
<h2>25. Waiting for Page Title</h2>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.title_is("Dashboard")
)</code></pre>
<p>To wait until the title contains specific text:</p>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.title_contains("Dashboard")
)</code></pre>
<h2>26. Waiting for URL</h2>
<p>URL-based waits are useful after navigation or login.</p>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.url_contains("/dashboard")
)</code></pre>
<h2>27. Waiting for an Alert</h2>
<p>When a JavaScript alert appears asynchronously, an explicit wait can be used.</p>
<pre><code>alert = WebDriverWait(
driver,
10
).until(
EC.alert_is_present()
)
alert.accept()</code></pre>
<h2>28. Waiting for a Frame</h2>
<p>When an iframe is loaded dynamically, Selenium can wait until the frame becomes available and switch into it.</p>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.frame_to_be_available_and_switch_to_it(
(By.ID, "payment-frame")
)
)</code></pre>
<h2>29. Waiting for Multiple Windows</h2>
<p>When clicking a link opens a new window or tab, the script can wait until the expected number of window handles exists.</p>
<pre><code>original_window = driver.current_window_handle
driver.find_element(
By.ID,
"open-window"
).click()
WebDriverWait(
driver,
10
).until(
EC.number_of_windows_to_be(2)
)</code></pre>
<h2>30. Custom Conditions with lambda</h2>
<p>Explicit waits can also use custom Python conditions through a lambda expression.</p>
<pre><code>WebDriverWait(
driver,
10
).until(
lambda d: d.find_element(
By.ID,
"status"
).text == "Completed"
)</code></pre>
<h2>31. Waiting for an Attribute</h2>
<p>Dynamic web applications may update attributes such as <code>class</code>, <code>value</code>, <code>disabled</code>, or custom data attributes.</p>
<pre><code>WebDriverWait(
driver,
10
).until(
lambda d: d.find_element(
By.ID,
"status"
).get_attribute("data-state") == "ready"
)</code></pre>
<h2>32. Waiting for an Element's Value</h2>
<pre><code>WebDriverWait(
driver,
10
).until(
lambda d: d.find_element(
By.ID,
"search"
).get_attribute("value") == "Selenium"
)</code></pre>
<h2>33. Waiting for a Button to Become Enabled</h2>
<pre><code>submit = WebDriverWait(
driver,
10
).until(
lambda d: (
element := d.find_element(
By.ID,
"submit"
)
).is_enabled() and element
)
submit.click()</code></pre>
<h2>34. Waiting for a Loader to Disappear</h2>
<pre><code>WebDriverWait(
driver,
15
).until(
EC.invisibility_of_element_located(
(By.CSS_SELECTOR, ".loader")
)
)
dashboard = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "dashboard")
)
)</code></pre>
<h2>35. Waiting for AJAX Content</h2>
<p>AJAX-based pages can update content without performing a complete page refresh. The automation script should wait for the application state that indicates the AJAX operation has completed.</p>
<pre><code>WebDriverWait(
driver,
15
).until(
EC.visibility_of_element_located(
(By.ID, "results")
)
)</code></pre>
<h2>36. Waiting for Dynamic Search Results</h2>
<pre><code>search_box = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "search")
)
)
search_box.send_keys("Laptop")
results = WebDriverWait(
driver,
10
).until(
EC.presence_of_all_elements_located(
(By.CSS_SELECTOR, ".search-result")
)
)
print("Results:", len(results))</code></pre>
<h2>37. Waiting for a Dynamic Login</h2>
<pre><code>username = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "username")
)
)
password = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "password")
)
)
login_button = WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "login")
)
)
username.send_keys("admin")
password.send_keys("admin123")
login_button.click()
WebDriverWait(
driver,
10
).until(
EC.url_contains("/dashboard")
)</code></pre>
<h2>38. Waiting for a Checkbox</h2>
<pre><code>checkbox = WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "terms")
)
)
if not checkbox.is_selected():
checkbox.click()</code></pre>
<h2>39. Waiting for a Dropdown</h2>
<pre><code>country = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "country")
)
)
from selenium.webdriver.support.ui import Select
Select(country).select_by_visible_text("India")</code></pre>
<h2>40. Waiting for a Link</h2>
<pre><code>documentation = WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.LINK_TEXT, "Documentation")
)
)
documentation.click()</code></pre>
<h2>41. Waiting for a Modal</h2>
<p>Modal dialogs may appear after a button click. Instead of using a fixed delay, wait for the modal to become visible.</p>
<pre><code>driver.find_element(
By.ID,
"open-modal"
).click()
modal = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "modal")
)
)
print(modal.text)</code></pre>
<h2>42. Waiting for a Loading Spinner</h2>
<pre><code>WebDriverWait(
driver,
15
).until(
EC.invisibility_of_element_located(
(By.CSS_SELECTOR, ".loading-spinner")
)
)</code></pre>
<h2>43. Waiting for Page Navigation</h2>
<p>After clicking a navigation link, the script can wait for a URL change or a specific element on the destination page.</p>
<pre><code>old_url = driver.current_url
driver.find_element(
By.ID,
"profile"
).click()
WebDriverWait(
driver,
10
).until(
lambda d: d.current_url != old_url
)</code></pre>
<h2>44. Waiting for Stale Elements</h2>
<p>Dynamic pages may replace DOM elements after an update. Selenium provides conditions that can be used when working with stale elements.</p>
<pre><code>element = driver.find_element(
By.ID,
"status"
)
driver.find_element(
By.ID,
"refresh"
).click()
WebDriverWait(
driver,
10
).until(
EC.staleness_of(element)
)</code></pre>
<h2>45. Handling TimeoutException</h2>
<p>If an explicit wait cannot satisfy its condition before the timeout, Selenium raises <code>TimeoutException</code>.</p>
<pre><code>from selenium.common.exceptions import TimeoutException
try:
login_button = WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "login")
)
)
login_button.click()
except TimeoutException:
print("Login button was not ready within the timeout")</code></pre>
<h2>46. Waits and Exception Handling</h2>
<p>Waits and exception handling have different purposes. A wait synchronizes the script with the application, while exception handling determines how the script responds when an operation fails.</p>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>Concept</th><th>Purpose</th></tr>
<tr><td>Wait</td><td>Synchronize with application state.</td></tr>
<tr><td>Exception handling</td><td>Handle unexpected execution failures.</td></tr>
<tr><td>Assertion</td><td>Validate expected test results.</td></tr>
</table>
<h2>47. Fluent Wait Concept</h2>
<p>Fluent wait is an advanced waiting approach where timeout, polling frequency, and ignored exceptions can be configured.</p>
<p>In Python, <code>WebDriverWait</code> can be configured with timeout, polling frequency, and ignored exceptions when required.</p>
<h3>Example</h3>
<pre><code>from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import NoSuchElementException
wait = WebDriverWait(
driver,
20,
poll_frequency=1,
ignored_exceptions=[NoSuchElementException]
)
element = wait.until(
EC.visibility_of_element_located(
(By.ID, "username")
)
)</code></pre>
<h2>48. Polling Frequency</h2>
<p>Polling frequency determines how often the wait checks the condition.</p>
<pre><code>wait = WebDriverWait(
driver,
20,
poll_frequency=1
)</code></pre>
<p>In this example, the condition is checked approximately once per second until it succeeds or the timeout is reached.</p>
<h2>49. Ignoring Specific Exceptions During a Wait</h2>
<p>In advanced scenarios, a wait may be configured to ignore selected exceptions while repeatedly checking a condition.</p>
<pre><code>from selenium.common.exceptions import NoSuchElementException
wait = WebDriverWait(
driver,
10,
ignored_exceptions=[
NoSuchElementException
]
)</code></pre>
<p>Exception ignoring should be used carefully. Ignoring too many exceptions can hide genuine automation problems.</p>
<h2>50. Implicit Wait vs Explicit Wait</h2>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>Feature</th><th>Implicit Wait</th><th>Explicit Wait</th></tr>
<tr><td>Scope</td><td>Global element location behavior.</td><td>Specific operation or condition.</td></tr>
<tr><td>Condition</td><td>Element location.</td><td>Custom or predefined condition.</td></tr>
<tr><td>Precision</td><td>Lower.</td><td>Higher.</td></tr>
<tr><td>Dynamic UI Handling</td><td>Limited.</td><td>Strong.</td></tr>
<tr><td>Readability</td><td>Simple.</td><td>Very expressive.</td></tr>
<tr><td>Typical Usage</td><td>Basic synchronization.</td><td>Professional automation.</td></tr>
</table>
<h2>51. Explicit Wait vs sleep()</h2>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>sleep()</th><th>Explicit Wait</th></tr>
<tr><td>Waits for a fixed amount of time.</td><td>Waits for a condition.</td></tr>
<tr><td>Does not know whether the application is ready.</td><td>Checks application state.</td></tr>
<tr><td>Can waste execution time.</td><td>Continues as soon as condition succeeds.</td></tr>
<tr><td>Less flexible.</td><td>More flexible.</td></tr>
<tr><td>Useful for specific non-Selenium timing needs.</td><td>Preferred for Selenium synchronization.</td></tr>
</table>
<h2>52. Why Avoid Excessive time.sleep()?</h2>
<pre><code>time.sleep(10)
driver.find_element(
By.ID,
"submit"
).click()</code></pre>
<p>If the element becomes ready after two seconds, the script still waits for the complete ten seconds. If the element takes longer than ten seconds, the script may still fail.</p>
<p>A condition-based wait can stop as soon as the required condition becomes true.</p>
<h2>53. Better Alternative to sleep()</h2>
<pre><code>submit = WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "submit")
)
)
submit.click()</code></pre>
<h2>54. Do Not Mix Wait Strategies Unnecessarily</h2>
<p>Using implicit and explicit waits together can make timeout behavior harder to understand. A project should establish a consistent synchronization strategy and use waits according to the needs of the application.</p>
<h2>55. Waits Inside Page Object Model</h2>
<p>Wait logic can be placed inside Page Object classes so that test cases remain focused on business behavior.</p>
<pre><code>from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
class LoginPage:
USERNAME = (By.ID, "username")
PASSWORD = (By.ID, "password")
LOGIN_BUTTON = (By.ID, "login")
def __init__(self, driver):
self.driver = driver
self.wait = WebDriverWait(
driver,
10
)
def login(self, username, password):
self.wait.until(
EC.visibility_of_element_located(
self.USERNAME
)
).send_keys(username)
self.wait.until(
EC.visibility_of_element_located(
self.PASSWORD
)
).send_keys(password)
self.wait.until(
EC.element_to_be_clickable(
self.LOGIN_BUTTON
)
).click()</code></pre>
<h2>56. Reusable Wait Helper</h2>
<p>A reusable utility class can centralize common waiting operations.</p>
<pre><code>from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
class WaitHelper:
def __init__(self, driver, timeout=10):
self.driver = driver
self.wait = WebDriverWait(
driver,
timeout
)
def visible(self, locator):
return self.wait.until(
EC.visibility_of_element_located(
locator
)
)
def clickable(self, locator):
return self.wait.until(
EC.element_to_be_clickable(
locator
)
)
def present(self, locator):
return self.wait.until(
EC.presence_of_element_located(
locator
)
)</code></pre>
<h2>57. Using a Wait Helper</h2>
<pre><code>wait = WaitHelper(driver)
username = wait.visible(
(By.ID, "username")
)
username.send_keys("admin")
login = wait.clickable(
(By.ID, "login")
)
login.click()</code></pre>
<h2>58. Waiting for API-Driven UI Updates</h2>
<p>Many modern applications use APIs to load or update information after the initial page load. Selenium should normally wait for a user-visible application state that confirms the operation is ready.</p>
<pre><code>driver.find_element(
By.ID,
"load-data"
).click()
WebDriverWait(
driver,
15
).until(
EC.visibility_of_element_located(
(By.ID, "data-table")
)
)</code></pre>
<h2>59. Waiting for a Table to Load</h2>
<pre><code>rows = WebDriverWait(
driver,
15
).until(
EC.presence_of_all_elements_located(
(By.CSS_SELECTOR, "#users tbody tr")
)
)
print("Rows:", len(rows))</code></pre>
<h2>60. Waiting for Search Result Text</h2>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.text_to_be_present_in_element(
(By.ID, "result-message"),
"Results found"
)
)</code></pre>
<h2>61. Waiting for an Element to Become Enabled</h2>
<pre><code>submit = WebDriverWait(
driver,
10
).until(
lambda d: (
element := d.find_element(
By.ID,
"submit"
)
) if element.is_enabled() else False
)</code></pre>
<p>For simpler cases, <code>element_to_be_clickable()</code> is often more readable when the required behavior is simply to wait until an element is visible and enabled for clicking.</p>
<h2>62. Waiting for a Checkbox to be Selected</h2>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.element_to_be_selected(
(By.ID, "terms")
)
)</code></pre>
<h2>63. Waiting for a Specific URL</h2>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.url_to_be(
"https://example.com/dashboard"
)
)</code></pre>
<h2>64. Waiting for a Partial URL</h2>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.url_contains("/dashboard")
)</code></pre>
<h2>65. Waiting for a New Window</h2>
<pre><code>original_window = driver.current_window_handle
driver.find_element(
By.ID,
"open-report"
).click()
WebDriverWait(
driver,
10
).until(
EC.number_of_windows_to_be(2)
)
for handle in driver.window_handles:
if handle != original_window:
driver.switch_to.window(handle)
break</code></pre>
<h2>66. Waiting for a Frame</h2>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.frame_to_be_available_and_switch_to_it(
(By.ID, "payment-frame")
)
)
card_number = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "card-number")
)
)
card_number.send_keys(
"4111111111111111"
)
driver.switch_to.default_content()</code></pre>
<h2>67. Waiting for an Alert</h2>
<pre><code>driver.find_element(
By.ID,
"delete"
).click()
alert = WebDriverWait(
driver,
10
).until(
EC.alert_is_present()
)
print(alert.text)
alert.accept()</code></pre>
<h2>68. Waiting for Dynamic Buttons</h2>
<pre><code>button = WebDriverWait(
driver,
15
).until(
EC.element_to_be_clickable(
(By.CSS_SELECTOR, "button.submit")
)
)
button.click()</code></pre>
<h2>69. Waiting for a Message to Disappear</h2>
<pre><code>WebDriverWait(
driver,
10
).until(
EC.invisibility_of_element_located(
(By.ID, "processing-message")
)
)</code></pre>
<h2>70. Waiting for an Element to Become Stale</h2>
<pre><code>old_element = driver.find_element(
By.ID,
"results"
)
driver.find_element(
By.ID,
"refresh"
).click()
WebDriverWait(
driver,
10
).until(
EC.staleness_of(old_element)
)</code></pre>
<h2>71. Handling TimeoutException with Screenshot</h2>
<pre><code>from selenium.common.exceptions import TimeoutException
try:
WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "dashboard")
)
)
except TimeoutException:
driver.save_screenshot(
"timeout_failure.png"
)
raise</code></pre>
<h2>72. Logging Wait Failures</h2>
<pre><code>import logging
from selenium.common.exceptions import TimeoutException
try:
WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "submit")
)
)
except TimeoutException as e:
logging.error(
"Submit button was not clickable: %s",
e
)
raise</code></pre>
<h2>73. Wait Strategy for Login</h2>
<pre><code>Open Login Page
|
v
Wait for Username
|
v
Enter Username
|
v
Wait for Password
|
v
Enter Password
|
v
Wait for Login Button
|
v
Click Login
|
v
Wait for Dashboard
|
v
Validate Dashboard</code></pre>
<h2>74. Wait Strategy for E-Commerce</h2>
<pre><code>Open Store
|
v
Wait for Search Box
|
v
Search Product
|
v
Wait for Search Results
|
v
Select Product
|
v
Wait for Product Page
|
v
Wait for Add to Cart
|
v
Add Product
|
v
Wait for Cart
|
v
Validate Cart</code></pre>
<h2>75. Wait Strategy for Dynamic Forms</h2>
<pre><code>Open Form
|
v
Wait for Name Field
|
v
Enter Name
|
v
Wait for Email Field
|
v
Enter Email
|
v
Wait for Country Dropdown
|
v
Select Country
|
v
Wait for Submit
|
v
Click Submit
|
v
Wait for Success Message</code></pre>
<h2>76. Common Mistakes with Selenium Waits</h2>
<h3>Mistake 1: Using sleep() Everywhere</h3>
<pre><code>time.sleep(10)</code></pre>
<p>Fixed delays do not adapt to actual application state.</p>
<h3>Mistake 2: Using Too Short a Timeout</h3>
<pre><code>WebDriverWait(
driver,
1
).until(...)</code></pre>
<p>A timeout should be based on realistic application behavior and environment conditions.</p>
<h3>Mistake 3: Using Very Large Timeouts Everywhere</h3>
<pre><code>WebDriverWait(
driver,
300
).until(...)</code></pre>
<p>Very large timeouts can make failures take unnecessarily long to surface.</p>
<h3>Mistake 4: Waiting for the Wrong Condition</h3>
<p>For example, waiting only for presence when the actual requirement is that the element must be visible and clickable.</p>
<h3>Mistake 5: Mixing Implicit and Explicit Waits Without a Strategy</h3>
<p>This can make execution timing harder to predict and debug.</p>
<h3>Mistake 6: Using Fixed Delays After Every Action</h3>
<pre><code>click()
time.sleep(5)
send_keys()
time.sleep(5)</code></pre>
<p>Use condition-based synchronization where possible.</p>
<h3>Mistake 7: Ignoring TimeoutException</h3>
<pre><code>try:
WebDriverWait(driver, 10).until(...)
except TimeoutException:
pass</code></pre>
<p>Silently ignoring timeout failures can hide real application or automation problems.</p>
<hr>
<h2>77. Best Practices for Selenium Waits</h2>
<ul>
<li>Prefer explicit waits for dynamic application conditions.</li>
<li>Use meaningful expected conditions.</li>
<li>Choose timeouts based on realistic application behavior.</li>
<li>Avoid unnecessary <code>time.sleep()</code> calls.</li>
<li>Keep wait logic reusable.</li>
<li>Use Page Object Model for large projects.</li>
<li>Wait for the state required by the next action.</li>
<li>Use <code>element_to_be_clickable()</code> before important clicks when appropriate.</li>
<li>Use visibility conditions before visual interactions.</li>
<li>Use presence conditions when DOM presence is sufficient.</li>
<li>Wait for loaders and overlays to disappear when they block interaction.</li>
<li>Handle <code>TimeoutException</code> appropriately.</li>
<li>Capture screenshots when wait failures are important for debugging.</li>
<li>Log important synchronization failures.</li>
<li>Avoid blindly increasing timeout values to hide synchronization problems.</li>
<li>Keep the synchronization strategy consistent throughout the project.</li>
</ul>
<h2>78. Good Wait Strategy vs Poor Wait Strategy</h2>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>Poor Strategy</th><th>Better Strategy</th></tr>
<tr><td>Use sleep() everywhere</td><td>Use condition-based explicit waits</td></tr>
<tr><td>Wait 30 seconds for every action</td><td>Use appropriate condition-specific timeouts</td></tr>
<tr><td>Wait for presence before every click</td><td>Use clickable condition when clicking</td></tr>
<tr><td>Ignore TimeoutException</td><td>Log, diagnose, and handle appropriately</td></tr>
<tr><td>Mix waits randomly</td><td>Use a consistent synchronization strategy</td></tr>
<tr><td>Repeat wait code everywhere</td><td>Create reusable wait utilities</td></tr>
<tr><td>Wait for arbitrary time</td><td>Wait for application state</td></tr>
</table>
<h2>79. Practical Project: Dynamic Login Automation</h2>
<p>Create a Selenium Python login test for a page where the login form loads dynamically.</p>
<h3>Requirements</h3>
<ol>
<li>Open the login page.</li>
<li>Wait for the username field.</li>
<li>Enter the username.</li>
<li>Wait for the password field.</li>
<li>Enter the password.</li>
<li>Wait for the login button to become clickable.</li>
<li>Click the login button.</li>
<li>Wait for the dashboard URL.</li>
<li>Validate the dashboard.</li>
<li>Capture a screenshot if a timeout occurs.</li>
<li>Close the browser.</li>
</ol>
<h3>Example</h3>
<pre><code>from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException
driver = webdriver.Chrome()
try:
driver.get(
"https://example.com/login"
)
wait = WebDriverWait(driver, 10)
username = wait.until(
EC.visibility_of_element_located(
(By.ID, "username")
)
)
password = wait.until(
EC.visibility_of_element_located(
(By.ID, "password")
)
)
login_button = wait.until(
EC.element_to_be_clickable(
(By.ID, "login")
)
)
username.send_keys("admin")
password.send_keys("admin123")
login_button.click()
wait.until(
EC.url_contains("/dashboard")
)
assert "/dashboard" in driver.current_url
except TimeoutException:
driver.save_screenshot(
"login_timeout.png"
)
raise
finally:
driver.quit()</code></pre>
<h2>80. Practical Project: Dynamic Search Test</h2>
<pre><code>from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.Chrome()
try:
driver.get(
"https://example.com/search"
)
wait = WebDriverWait(driver, 10)
search = wait.until(
EC.visibility_of_element_located(
(By.ID, "search")
)
)
search.send_keys("Laptop")
search.send_keys(Keys.ENTER)
results = wait.until(
EC.presence_of_all_elements_located(
(By.CSS_SELECTOR, ".result")
)
)
assert len(results) > 0
finally:
driver.quit()</code></pre>
<h2>81. Practical Project: Dynamic E-Commerce Cart</h2>
<p>Build an e-commerce automation test that waits for each application state before continuing.</p>
<pre><code>Open Store
|
v
Wait for Search
|
v
Search Product
|
v
Wait for Results
|
v
Select Product
|
v
Wait for Product Page
|
v
Wait for Add to Cart
|
v
Add to Cart
|
v
Wait for Cart
|
v
Validate Product
|
v
Validate Price
|
v
Checkout</code></pre>
<h2>82. Practical Project: Loader Handling</h2>
<p>Many applications display a loading spinner while data is being retrieved. The automation should wait for the spinner to disappear before interacting with the resulting content.</p>
<pre><code>driver.find_element(
By.ID,
"load-data"
).click()
WebDriverWait(
driver,
15
).until(
EC.invisibility_of_element_located(
(By.ID, "loader")
)
)
table = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "data-table")
)
)</code></pre>
<h2>83. Practical Project: Frame Wait</h2>
<pre><code>WebDriverWait(
driver,
15
).until(
EC.frame_to_be_available_and_switch_to_it(
(By.ID, "payment-frame")
)
)
card = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "card-number")
)
)
card.send_keys(
"4111111111111111"
)
driver.switch_to.default_content()</code></pre>
<h2>84. Practical Project: Alert Wait</h2>
<pre><code>driver.find_element(
By.ID,
"delete-account"
).click()
alert = WebDriverWait(
driver,
10
).until(
EC.alert_is_present()
)
print(alert.text)
alert.accept()</code></pre>
<h2>85. Practical Project: New Window Wait</h2>
<pre><code>original_window = driver.current_window_handle
driver.find_element(
By.ID,
"open-report"
).click()
WebDriverWait(
driver,
10
).until(
EC.number_of_windows_to_be(2)
)
for handle in driver.window_handles:
if handle != original_window:
driver.switch_to.window(handle)
break
print(driver.title)</code></pre>
<hr>
<h2>86. Waits in a Professional Selenium Framework</h2>
<p>In a professional automation framework, synchronization logic should not be scattered randomly throughout test cases. Common wait operations can be centralized into page objects or utility classes.</p>
<pre><code>selenium_project/
|
+-- tests/
| +-- test_login.py
| +-- test_search.py
| +-- test_cart.py
|
+-- pages/
| +-- login_page.py
| +-- search_page.py
| +-- cart_page.py
|
+-- utilities/
| +-- wait_helper.py
| +-- screenshot_helper.py
| +-- logger.py
|
+-- test_data/
|
+-- screenshots/
|
+-- reports/
|
+-- conftest.py
|
+-- requirements.txt</code></pre>
<h2>87. Recommended Wait Architecture</h2>
<pre><code>Test Case
|
v
Page Object
|
v
Wait Helper
|
v
WebDriverWait
|
v
Expected Condition
|
v
Web Application State
|
v
Element Ready
|
v
Perform Action</code></pre>
<h2>88. Waits with pytest Fixture</h2>
<pre><code>import pytest
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
@pytest.fixture
def driver():
browser = webdriver.Chrome()
yield browser
browser.quit()
@pytest.fixture
def wait(driver):
return WebDriverWait(
driver,
10
)</code></pre>
<h3>Using the Fixture</h3>
<pre><code>def test_login(driver, wait):
driver.get(
"https://example.com/login"
)
username = wait.until(
EC.visibility_of_element_located(
(By.ID, "username")
)
)
username.send_keys("admin")</code></pre>
<h2>89. Waits and Test Assertions</h2>
<p>A wait should synchronize the test before an assertion is performed.</p>
<pre><code>dashboard = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "dashboard")
)
)
assert dashboard.is_displayed()</code></pre>
<p>The wait ensures the expected application state has been reached before the assertion checks the result.</p>
<h2>90. Waits and Exception Handling</h2>
<pre><code>try:
dashboard = WebDriverWait(
driver,
10
).until(
EC.visibility_of_element_located(
(By.ID, "dashboard")
)
)
assert dashboard.is_displayed()
except TimeoutException:
driver.save_screenshot(
"dashboard_timeout.png"
)
raise</code></pre>
<h2>91. Waits and Screenshots</h2>
<p>When a wait fails, a screenshot can provide useful information about the browser state at the time of failure.</p>
<pre><code>try:
WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "checkout")
)
)
except TimeoutException:
driver.save_screenshot(
"checkout_wait_failure.png"
)
raise</code></pre>
<h2>92. Waits and Logging</h2>
<pre><code>import logging
logging.info(
"Waiting for checkout button"
)
checkout = WebDriverWait(
driver,
10
).until(
EC.element_to_be_clickable(
(By.ID, "checkout")
)
)
logging.info(
"Checkout button is ready"
)
checkout.click()</code></pre>
<h2>93. Choosing the Correct Expected Condition</h2>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>Requirement</th><th>Recommended Condition</th></tr>
<tr><td>Element exists in DOM</td><td><code>presence_of_element_located()</code></td></tr>
<tr><td>Element is visible</td><td><code>visibility_of_element_located()</code></td></tr>
<tr><td>Element should be clicked</td><td><code>element_to_be_clickable()</code></td></tr>
<tr><td>Multiple elements exist</td><td><code>presence_of_all_elements_located()</code></td></tr>
<tr><td>All elements visible</td><td><code>visibility_of_all_elements_located()</code></td></tr>
<tr><td>Loader disappears</td><td><code>invisibility_of_element_located()</code></td></tr>
<tr><td>Text appears</td><td><code>text_to_be_present_in_element()</code></td></tr>
<tr><td>Page title changes</td><td><code>title_is()</code> or <code>title_contains()</code></td></tr>
<tr><td>URL changes</td><td><code>url_to_be()</code> or <code>url_contains()</code></td></tr>
<tr><td>Alert appears</td><td><code>alert_is_present()</code></td></tr>
<tr><td>Frame becomes available</td><td><code>frame_to_be_available_and_switch_to_it()</code></td></tr>
<tr><td>New window opens</td><td><code>number_of_windows_to_be()</code></td></tr>
<tr><td>Old element disappears after DOM replacement</td><td><code>staleness_of()</code></td></tr>
</table>
<h2>94. Quick Revision Table</h2>
<table border="1" cellpadding="8" cellspacing="0">
<tr><th>Concept</th><th>Example</th><th>Purpose</th></tr>
<tr><td>Implicit Wait</td><td><code>driver.implicitly_wait(10)</code></td><td>Global element-location timeout.</td></tr>
<tr><td>Explicit Wait</td><td><code>WebDriverWait(driver, 10).until(...)</code></td><td>Wait for a specific condition.</td></tr>
<tr><td>Presence</td><td><code>EC.presence_of_element_located()</code></td><td>Element exists in DOM.</td></tr>
<tr><td>Visibility</td><td><code>EC.visibility_of_element_located()</code></td><td>Element is visible.</td></tr>
<tr><td>Clickable</td><td><code>EC.element_to_be_clickable()</code></td><td>Element is ready for clicking.</td></tr>
<tr><td>Invisibility</td><td><code>EC.invisibility_of_element_located()</code></td><td>Element disappears or becomes invisible.</td></tr>
<tr><td>Text</td><td><code>EC.text_to_be_present_in_element()</code></td><td>Wait for specific text.</td></tr>
<tr><td>URL</td><td><code>EC.url_contains()</code></td><td>Wait for URL condition.</td></tr>
<tr><td>Title</td><td><code>EC.title_contains()</code></td><td>Wait for title condition.</td></tr>
<tr><td>Alert</td><td><code>EC.alert_is_present()</code></td><td>Wait for alert.</td></tr>
<tr><td>Frame</td><td><code>EC.frame_to_be_available_and_switch_to_it()</code></td><td>Wait and switch to frame.</td></tr>
<tr><td>Windows</td><td><code>EC.number_of_windows_to_be()</code></td><td>Wait for window count.</td></tr>
<tr><td>Stale Element</td><td><code>EC.staleness_of()</code></td><td>Wait for old element to become stale.</td></tr>
<tr><td>Timeout</td><td><code>TimeoutException</code></td><td>Handle unsuccessful waits.</td></tr>
</table>
<h2>95. Interview Questions on Selenium Waits</h2>
<h3>Q1. What is a wait in Selenium?</h3>
<p>A wait is a synchronization mechanism that allows Selenium to wait for an element or application condition before continuing execution.</p>
<h3>Q2. What are the main types of waits?</h3>
<p>The commonly discussed Selenium wait mechanisms are implicit waits, explicit waits, and fluent-style configurable waits.</p>
<h3>Q3. What is an implicit wait?</h3>
<p>An implicit wait sets a global timeout used when WebDriver searches for elements.</p>
<h3>Q4. What is an explicit wait?</h3>
<p>An explicit wait waits for a specific condition before allowing the script to continue.</p>
<h3>Q5. What is WebDriverWait?</h3>
<p><code>WebDriverWait</code> is Selenium's Python wait utility for waiting until a condition succeeds or the timeout is reached.</p>
<h3>Q6. What is Expected Conditions?</h3>
<p>Expected Conditions are predefined conditions that can be used with explicit waits for common synchronization scenarios.</p>
<h3>Q7. What is the difference between presence and visibility?</h3>
<p>Presence means that the element exists in the DOM. Visibility means that the element exists and is visible on the page.</p>
<h3>Q8. What is element_to_be_clickable()?</h3>
<p>It is an expected condition used when an element needs to be visible and enabled for clicking.</p>
<h3>Q9. What exception occurs when an explicit wait times out?</h3>
<p>Selenium raises <code>TimeoutException</code> when the wait condition is not satisfied before the timeout.</p>
<h3>Q10. Why should sleep() not be used everywhere?</h3>
<p><code>sleep()</code> waits for a fixed duration and does not check whether the application is already ready. Condition-based waits are generally more suitable for Selenium synchronization.</p>
<h3>Q11. Can Selenium wait for text?</h3>
<p>Yes. Expected Conditions provide text-related conditions such as <code>text_to_be_present_in_element()</code>.</p>
<h3>Q12. Can Selenium wait for a URL?</h3>
<p>Yes. Conditions such as <code>url_to_be()</code> and <code>url_contains()</code> can be used.</p>
<h3>Q13. Can Selenium wait for an alert?</h3>
<p>Yes. <code>EC.alert_is_present()</code> can be used with <code>WebDriverWait</code>.</p>
<h3>Q14. Can Selenium wait for a frame?</h3>
<p>Yes. <code>frame_to_be_available_and_switch_to_it()</code> can wait for a frame and switch into it.</p>
<h3>Q15. How can waits be reused in Page Object Model?</h3>
<p>A reusable <code>WebDriverWait</code> object or wait helper class can be maintained inside page objects or utility classes.</p>
<h3>Q16. What is polling frequency?</h3>
<p>Polling frequency determines how frequently a wait checks the specified condition.</p>
<h3>Q17. What is a timeout?</h3>
<p>A timeout is the maximum period the wait is allowed to keep checking a condition before failing.</p>
<h3>Q18. What is the difference between wait and assertion?</h3>
<p>A wait synchronizes execution with application state, while an assertion verifies whether the actual result matches the expected result.</p>
<hr>
<h2>96. Recommended Selenium Wait Flow</h2>
<pre><code>Start Test
|
v
Open Application
|
v
Identify Required Element
|
v
Choose Locator
|
v
Choose Correct Wait Condition
|
v
Set Reasonable Timeout
|
v
Wait for Condition
|
v
Condition Satisfied?
/ \
Yes No
| |
v v
Perform Timeout
Action |
v
Capture Evidence
|
v
Log Failure
|
v
Raise Error</code></pre>
<h2>97. Professional Selenium Wait Strategy</h2>
<pre><code>Requirement
|
v
Identify Application State
|
v
Select Stable Locator
|
v
Select Appropriate Condition
|
v
Configure WebDriverWait
|
v
Wait for Condition
|
v
Perform Action
|
v
Validate Result
|
v
Continue Test
|
v
Cleanup</code></pre>
<h2>98. Final Summary</h2>
<p>Waits are a fundamental part of reliable Selenium automation with Python. Web applications often contain dynamically loaded elements, asynchronous operations, animations, AJAX requests, overlays, frames, alerts, and changing page states. Selenium scripts therefore need synchronization mechanisms that respond to actual application conditions.</p>
<p>Implicit waits provide a global element-location timeout, while explicit waits allow the automation script to wait for specific conditions. <code>WebDriverWait</code> combined with Expected Conditions is particularly useful for dynamic web applications because it allows the test to wait for the state required by the next operation.</p>
<p>Common conditions include waiting for element presence, visibility, clickability, text, URL changes, title changes, alerts, frames, multiple windows, invisibility, and stale elements. Custom lambda conditions can also be used when a predefined condition does not represent the required application state.</p>
<p>Professional Selenium automation should avoid excessive fixed delays, use appropriate synchronization conditions, handle <code>TimeoutException</code> correctly, capture useful debugging information, and centralize reusable wait logic where appropriate.</p>
<p>The main goal of Selenium waits is to make automation <strong>stable, synchronized, reliable, readable, maintainable, and suitable for dynamic web applications</strong>.</p>
<h2>99. Course Resources</h2>
<p><strong>Selenium Training:</strong> <a href="https://www.justacademy.co/course-detail/selenium-training" target="_blank" rel="noopener noreferrer">https://www.justacademy.co/course-detail/selenium-training</a></p>
<p><strong>Register for Course Demo:</strong> <a href="https://www.justacademy.co/register-for-course-demo" target="_blank" rel="noopener noreferrer">https://www.justacademy.co/register-for-course-demo</a></p>
</div>
